#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

//#include <stdio.h>
//#include <ctype.h>
//#include <string.h>
//int main()
//{
//    int n = 0;
//    scanf("%d", &n);
//    char s[101] = { 0 };
//    while (n--)
//    {
//        scanf("%s", s);
//        int flag = 1;
//        int flag_A = 0, flag_a = 0, flag_0 = 0;
//        for (char* str = s; *str != '\0'; str++)
//        {
//            if (islower(*str))
//                flag_a = 1;
//            else if (isupper(*str))
//                flag_A = 1;
//            else if (isdigit(*str))
//                flag_0 = 1;
//            else
//                flag = 0;
//        }
//        if (flag_0 + flag_A + flag_a < 2)
//            flag = 0;
//        if (isdigit(*s) || strlen(s) < 8)
//        {
//            flag = 0;
//        }
//        if (!flag)
//            printf("NO\n");
//        else
//            printf("YES\n");
//    }
//    return 0;
//}
//#include <stdlib.h>
//
//int* findErrorNums(int* nums, int numsSize, int* returnSize) {
//    int* tmp = (int*)calloc(2, sizeof(int));
//    *returnSize = 2;
//    if (!tmp)
//    {
//        perror("malloc");
//        exit(-1);
//    }
//    int k = 0;
//    for (int i = 0; i < numsSize; i++)
//    {
//        k ^= nums[i];
//    }
//    for (int i = 1; i <= numsSize; i++)
//    {
//        k ^= i;
//    }
//    int pos = 0;
//    for (int i = 0; i < 32; i++)
//    {
//        if (((k >> i) & 1) == 1)
//        {
//            pos = i;
//            break;
//        }
//    }
//    for (int i = 0; i < numsSize; i++)
//    {
//        if (((nums[i] >> pos) & 1) == 1)
//            tmp[0] ^= nums[i];
//    }
//    for (int i = 1; i <= numsSize; i++)
//    {
//        if (((i >> pos) & 1) == 1)
//            tmp[0] ^= i;
//    }
//    tmp[1] = k ^ tmp[0];
//    int flag = 0;
//    for (int i = 0; i < numsSize; i++)
//    {
//        if (nums[i] == tmp[0])
//            flag = 1;
//    }
//    if (!flag)
//    {
//        int result = tmp[0];
//        tmp[0] = tmp[1];
//        tmp[1] = result;
//    }
//    return tmp;
//}
//
//int main()
//{
//    int a[] = { 1,2,2,4 };
//    int sz = sizeof(a) / sizeof(a[0]);
//    int k = 0;
//    int* p = findErrorNums(a, sz, &k);
//    return 0;
//}

#include "SeqList.h"

void test1()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 9);
	SeqListPrint(&s);
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 0);
	SeqListPrint(&s);

	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPrint(&s);

	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s);

	//SeqListPopBack(&s);


	SeqListDestory(&s);
}

void test2()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 9);
	SeqListPrint(&s);

	int pos = SeqListFind(&s, 3);
	if (pos != -1)
	{
		SeqListInsert(&s, pos, 2);
	}
	SeqListPrint(&s);


	SeqListDestory(&s);
}

//int main()
//{
//	//test1();
//	test2();
//	return 0;
//}

//typedef int SLDataType;
//
//typedef struct SeqList
//{
//	SLDataType* _a;
//	int _size;
//	int _capacity;
//}SeqList;
//
//void SeqListInit(SeqList* ps);
//
//void SeqListDestory(SeqList* ps);
//
//void SeqListPrint(SeqList* ps);
//
//void SeqListInsert(SeqList* ps, int pos, SLDataType x);
//
//void SeqListErase(SeqList* ps, int pos);
//
//void SeqListPushBack(SeqList* ps, SLDataType x);
//
//void SeqListPushFront(SeqList* ps, SLDataType x);
//
//void SeqListPopFront(SeqList* ps);
//
//void SeqListPopBack(SeqList* ps);
//
//int SeqListFind(SeqList* ps, SLDataType x);
//
//void SeqListInit(SeqList* ps)
//{
//	assert(ps);
//
//	ps->_a = NULL;
//	ps->_capacity = ps->_size = 0;
//}
//
//void SeqListDestory(SeqList* ps)
//{
//	assert(ps);
//
//	free(ps->_a);
//	ps->_a = NULL;
//	ps->_size = ps->_capacity = 0;
//}
//
//void SeqListCheckCapacity(SeqList* ps)
//{
//	if (ps->_capacity == ps->_size)
//	{
//		int newcapacity = ps->_capacity == 0 ? 4 : 2 * ps->_capacity;
//		SLDataType* p = (SLDataType*)realloc(ps->_a, sizeof(SLDataType) * newcapacity);
//		if (!p)
//		{
//			perror("SeqListCheckCapacity");
//			exit(-1);
//		}
//		ps->_a = p;
//		ps->_capacity = newcapacity;
//	}
//}
//
//void SeqListPrint(SeqList* ps)
//{
//	assert(ps);
//	for (int i = 0; i < ps->_size; i++)
//	{
//		printf("%d  ", ps->_a[i]);
//	}
//	printf("\n");
//}
//
//void SeqListInsert(SeqList* ps, int pos, SLDataType x)
//{
//	assert(ps);
//	SeqListCheckCapacity(ps);
//	for (int i = ps->_size - 1; i >= pos; i--)
//	{
//		ps->_a[i + 1] = ps->_a[i];
//	}
//	ps->_a[pos] = x;
//	ps->_size++;
//}
//
//void SeqListErase(SeqList* ps, int pos)
//{
//	assert(ps);
//	assert(ps->_size > 0);
//
//	for (int i = pos; i < ps->_size - 1; i++)
//	{
//		ps->_a[i] = ps->_a[i + 1];
//	}
//	ps->_size--;
//}
//
//void SeqListPushBack(SeqList* ps, SLDataType x)
//{
//	assert(ps);
//
//	SeqListCheckCapacity(ps);
//	ps->_a[ps->_size++] = x;
//}
//
//void SeqListPushFront(SeqList* ps, SLDataType x)
//{
//	SeqListInsert(ps, 0, x);
//}
//
//void SeqListPopFront(SeqList* ps)
//{
//	SeqListErase(ps, 0);
//}
//
//void SeqListPopBack(SeqList* ps)
//{
//	assert(ps);
//	assert(ps->_size > 0);
//
//	ps->_size--;
//}
//
//int SeqListFind(SeqList* ps, SLDataType x)
//{
//	assert(ps);
//	for (int i = 0; i < ps->_size; i++)
//	{
//		if (ps->_a[i] == x)
//			return i;
//	}
//	return -1;
//}
//
///**
// * Note: The returned array must be malloced, assume caller calls free().
// */
//int* addToArrayForm(int* num, int numSize, int k, int* returnSize) {
//	num[numSize - 1] += k;
//	SeqList s;
//	SeqListInit(&s);
//	for (int i = 0; i < numSize; i++)
//	{
//		SeqListPushBack(&s, num[i]);
//	}
//	int c = 0;
//	for (int i = numSize - 1; i >= 0; i--)
//	{
//		s._a[i] += c;
//		c = (s._a[i]) / 10;
//		(s._a[i]) %= 10;
//	}
//	if (c != 0)
//	{
//		while (c)
//		{
//			SeqListPushFront(&s, c % 10);
//			c /= 10;
//		}
//	}
//	*returnSize = s._size;
//	int* p = (int*)malloc(sizeof(int) * (s._size));
//	memcpy(p, s._a, sizeof(int) * (s._size));
//	SeqListDestory(&s);
//	return p;
//}